package proto

import (
	"fmt"
	"io"
	math_bits "math/bits"

	"github.com/golang/protobuf/proto"
)

func init() {
	proto.RegisterType((*Field)(nil), "proto.Field")
	proto.RegisterType((*Row)(nil), "proto.Row")
	proto.RegisterType((*QueryResult)(nil), "proto.QueryResult")

	proto.RegisterEnum("proto.Type", Type_name, Type_value)
}

type Type int32

func (x Type) String() string {
	return proto.EnumName(Type_name, int32(x))
}

var Type_name = map[int32]string{
	0:     "NULL_TYPE",
	257:   "INT8",
	770:   "UINT8",
	259:   "INT16",
	772:   "UINT16",
	261:   "INT24",
	774:   "UINT24",
	263:   "INT32",
	776:   "UINT32",
	265:   "INT64",
	778:   "UINT64",
	1035:  "FLOAT32",
	1036:  "FLOAT64",
	2061:  "TIMESTAMP",
	2062:  "DATE",
	2063:  "TIME",
	2064:  "DATETIME",
	785:   "YEAR",
	18:    "DECIMAL",
	6163:  "TEXT",
	10260: "BLOB",
	6165:  "VARCHAR",
	10262: "VARBINARY",
	6167:  "CHAR",
	10264: "BINARY",
	2073:  "BIT",
	2074:  "ENUM",
	2075:  "SET",
	28:    "TUPLE",
	2077:  "GEOMETRY",
	2078:  "JSON",
	31:    "EXPRESSION",
}

// Flags sent from the MySQL C API
type MySqlFlag int32

const (
	MySqlFlag_EMPTY                 MySqlFlag = 0
	MySqlFlag_NOT_NULL_FLAG         MySqlFlag = 1
	MySqlFlag_PRI_KEY_FLAG          MySqlFlag = 2
	MySqlFlag_UNIQUE_KEY_FLAG       MySqlFlag = 4
	MySqlFlag_MULTIPLE_KEY_FLAG     MySqlFlag = 8
	MySqlFlag_BLOB_FLAG             MySqlFlag = 16
	MySqlFlag_UNSIGNED_FLAG         MySqlFlag = 32
	MySqlFlag_ZEROFILL_FLAG         MySqlFlag = 64
	MySqlFlag_BINARY_FLAG           MySqlFlag = 128
	MySqlFlag_ENUM_FLAG             MySqlFlag = 256
	MySqlFlag_AUTO_INCREMENT_FLAG   MySqlFlag = 512
	MySqlFlag_TIMESTAMP_FLAG        MySqlFlag = 1024
	MySqlFlag_SET_FLAG              MySqlFlag = 2048
	MySqlFlag_NO_DEFAULT_VALUE_FLAG MySqlFlag = 4096
	MySqlFlag_ON_UPDATE_NOW_FLAG    MySqlFlag = 8192
	MySqlFlag_NUM_FLAG              MySqlFlag = 32768
	MySqlFlag_PART_KEY_FLAG         MySqlFlag = 16384
	MySqlFlag_GROUP_FLAG            MySqlFlag = 32768
	MySqlFlag_UNIQUE_FLAG           MySqlFlag = 65536
	MySqlFlag_BINCMP_FLAG           MySqlFlag = 131072
)

const (
	// NULL_TYPE specifies a NULL type.
	Type_NULL_TYPE Type = 0
	// INT8 specifies a TINYINT type.
	// Properties: 1, IsNumber.
	Type_INT8 Type = 257
	// UINT8 specifies a TINYINT UNSIGNED type.
	// Properties: 2, IsNumber, IsUnsigned.
	Type_UINT8 Type = 770
	// INT16 specifies a SMALLINT type.
	// Properties: 3, IsNumber.
	Type_INT16 Type = 259
	// UINT16 specifies a SMALLINT UNSIGNED type.
	// Properties: 4, IsNumber, IsUnsigned.
	Type_UINT16 Type = 772
	// INT24 specifies a MEDIUMINT type.
	// Properties: 5, IsNumber.
	Type_INT24 Type = 261
	// UINT24 specifies a MEDIUMINT UNSIGNED type.
	// Properties: 6, IsNumber, IsUnsigned.
	Type_UINT24 Type = 774
	// INT32 specifies a INTEGER type.
	// Properties: 7, IsNumber.
	Type_INT32 Type = 263
	// UINT32 specifies a INTEGER UNSIGNED type.
	// Properties: 8, IsNumber, IsUnsigned.
	Type_UINT32 Type = 776
	// INT64 specifies a BIGINT type.
	// Properties: 9, IsNumber.
	Type_INT64 Type = 265
	// UINT64 specifies a BIGINT UNSIGNED type.
	// Properties: 10, IsNumber, IsUnsigned.
	Type_UINT64 Type = 778
	// FLOAT32 specifies a FLOAT type.
	// Properties: 11, IsFloat.
	Type_FLOAT32 Type = 1035
	// FLOAT64 specifies a DOUBLE or REAL type.
	// Properties: 12, IsFloat.
	Type_FLOAT64 Type = 1036
	// TIMESTAMP specifies a TIMESTAMP type.
	// Properties: 13, IsQuoted.
	Type_TIMESTAMP Type = 2061
	// DATE specifies a DATE type.
	// Properties: 14, IsQuoted.
	Type_DATE Type = 2062
	// TIME specifies a TIME type.
	// Properties: 15, IsQuoted.
	Type_TIME Type = 2063
	// DATETIME specifies a DATETIME type.
	// Properties: 16, IsQuoted.
	Type_DATETIME Type = 2064
	// YEAR specifies a YEAR type.
	// Properties: 17, IsNumber, IsUnsigned.
	Type_YEAR Type = 785
	// DECIMAL specifies a DECIMAL or NUMERIC type.
	// Properties: 18, None.
	Type_DECIMAL Type = 18
	// TEXT specifies a TEXT type.
	// Properties: 19, IsQuoted, IsText.
	Type_TEXT Type = 6163
	// BLOB specifies a BLOB type.
	// Properties: 20, IsQuoted, IsBinary.
	Type_BLOB Type = 10260
	// VARCHAR specifies a VARCHAR type.
	// Properties: 21, IsQuoted, IsText.
	Type_VARCHAR Type = 6165
	// VARBINARY specifies a VARBINARY type.
	// Properties: 22, IsQuoted, IsBinary.
	Type_VARBINARY Type = 10262
	// CHAR specifies a CHAR type.
	// Properties: 23, IsQuoted, IsText.
	Type_CHAR Type = 6167
	// BINARY specifies a BINARY type.
	// Properties: 24, IsQuoted, IsBinary.
	Type_BINARY Type = 10264
	// BIT specifies a BIT type.
	// Properties: 25, IsQuoted.
	Type_BIT Type = 2073
	// ENUM specifies an ENUM type.
	// Properties: 26, IsQuoted.
	Type_ENUM Type = 2074
	// SET specifies a SET type.
	// Properties: 27, IsQuoted.
	Type_SET Type = 2075
	// TUPLE specifies a tuple. This cannot
	// be returned in a QueryResult, but it can
	// be sent as a bind var.
	// Properties: 28, None.
	Type_TUPLE Type = 28
	// GEOMETRY specifies a GEOMETRY type.
	// Properties: 29, IsQuoted.
	Type_GEOMETRY Type = 2077
	// JSON specifies a JSON type.
	// Properties: 30, IsQuoted.
	Type_JSON Type = 2078
	// EXPRESSION specifies a SQL expression.
	// This type is for internal use only.
	// Properties: 31, None.
	Type_EXPRESSION Type = 31
)

var Type_value = map[string]int32{
	"NULL_TYPE":  0,
	"INT8":       257,
	"UINT8":      770,
	"INT16":      259,
	"UINT16":     772,
	"INT24":      261,
	"UINT24":     774,
	"INT32":      263,
	"UINT32":     776,
	"INT64":      265,
	"UINT64":     778,
	"FLOAT32":    1035,
	"FLOAT64":    1036,
	"TIMESTAMP":  2061,
	"DATE":       2062,
	"TIME":       2063,
	"DATETIME":   2064,
	"YEAR":       785,
	"DECIMAL":    18,
	"TEXT":       6163,
	"BLOB":       10260,
	"VARCHAR":    6165,
	"VARBINARY":  10262,
	"CHAR":       6167,
	"BINARY":     10264,
	"BIT":        2073,
	"ENUM":       2074,
	"SET":        2075,
	"TUPLE":      28,
	"GEOMETRY":   2077,
	"JSON":       2078,
	"EXPRESSION": 31,
}

// Field describes a single column returned by a query
type Field struct {
	// name of the field as returned by mysql C API
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// vitess-defined type. Conversion function is in sqltypes package.
	Type Type `protobuf:"varint,2,opt,name=type,proto3,enum=proto.Type" json:"type,omitempty"`
	// Remaining fields from mysql C API.
	// These fields are only populated when ExecuteOptions.included_fields
	// is set to IncludedFields.ALL.
	Table    string `protobuf:"bytes,3,opt,name=table,proto3" json:"table,omitempty"`
	OrgTable string `protobuf:"bytes,4,opt,name=org_table,json=orgTable,proto3" json:"org_table,omitempty"`
	Database string `protobuf:"bytes,5,opt,name=database,proto3" json:"database,omitempty"`
	OrgName  string `protobuf:"bytes,6,opt,name=org_name,json=orgName,proto3" json:"org_name,omitempty"`
	// column_length is really a uint32. All 32 bits can be used.
	ColumnLength uint32 `protobuf:"varint,7,opt,name=column_length,json=columnLength,proto3" json:"column_length,omitempty"`
	// charset is actually a uint16. Only the lower 16 bits are used.
	Charset uint32 `protobuf:"varint,8,opt,name=charset,proto3" json:"charset,omitempty"`
	// decimals is actually a uint8. Only the lower 8 bits are used.
	Decimals uint32 `protobuf:"varint,9,opt,name=decimals,proto3" json:"decimals,omitempty"`
	// flags is actually a uint16. Only the lower 16 bits are used.
	Flags uint32 `protobuf:"varint,10,opt,name=flags,proto3" json:"flags,omitempty"`
	// column_type is optionally populated from information_schema.columns
	ColumnType       string `protobuf:"bytes,11,opt,name=column_type,json=columnType,proto3" json:"column_type,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Field) Reset()         { *m = Field{} }
func (m *Field) String() string { return proto.CompactTextString(m) }
func (*Field) ProtoMessage()    {}

func (*Field) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c6ac9b241082464, []int{7}
}

func (m *Field) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Field.Unmarshal(m, b)
}
func (m *Field) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Field.Marshal(b, m, deterministic)
}
func (m *Field) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Field.Merge(m, src)
}
func (m *Field) XXX_Size() int {
	return xxx_messageInfo_Field.Size(m)
}
func (m *Field) XXX_DiscardUnknown() {
	xxx_messageInfo_Field.DiscardUnknown(m)
}

type Flag int32

const (
	Flag_NONE       Flag = 0
	Flag_ISINTEGRAL Flag = 256
	Flag_ISUNSIGNED Flag = 512
	Flag_ISFLOAT    Flag = 1024
	Flag_ISQUOTED   Flag = 2048
	Flag_ISTEXT     Flag = 4096
	Flag_ISBINARY   Flag = 8192
)

type Row struct {
	// lengths contains the length of each value in values.
	// A length of -1 means that the field is NULL. While
	// reading values, you have to accummulate the length
	// to know the offset where the next value begins in values.
	Lengths []int64 `protobuf:"zigzag64,1,rep,packed,name=lengths,proto3" json:"lengths,omitempty"`
	// values contains a concatenation of all values in the row.
	Values []byte `protobuf:"bytes,2,opt,name=values,proto3" json:"values,omitempty"`
}

func (m *Row) Reset()         { *m = Row{} }
func (m *Row) String() string { return proto.CompactTextString(m) }
func (*Row) ProtoMessage()    {}

func (m *Row) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Row.Unmarshal(m, b)
}
func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Row.Marshal(b, m, deterministic)
}
func (m *Row) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Row.Merge(m, src)
}
func (m *Row) XXX_Size() int {
	return xxx_messageInfo_Row.Size(m)
}
func (m *Row) XXX_DiscardUnknown() {
	xxx_messageInfo_Row.DiscardUnknown(m)
}

var xxx_messageInfo_Row proto.InternalMessageInfo

func (m *Row) GetLengths() []int64 {
	if m != nil {
		return m.Lengths
	}
	return nil
}

func (m *Row) GetValues() []byte {
	if m != nil {
		return m.Values
	}
	return nil
}

func (*Row) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c6ac9b241082464, []int{8}
}

type TableDefinition struct {
	// the table name
	Name string
	// the SQL to run to create the table
	Schema string
	// the columns in the order that will be used to dump and load the data
	Columns []string
	// the primary key columns in the primary key order
	PrimaryKeyColumns []string
	// type is either mysqlctl.TableBaseTable or mysqlctl.TableView
	Type string
	// how much space the data file takes.
	DataLength uint64
	// approximate number of rows
	RowCount uint64
	// column names along with their types.
	// NOTE: this is a superset of columns.
	Fields []*Field
}

type SchemaDefinition struct {
	DatabaseSchema   string
	TableDefinitions []*TableDefinition
	Version          string
}

type ExecuteOptions_IncludedFields int32

const (
	ExecuteOptions_TYPE_AND_NAME ExecuteOptions_IncludedFields = 0
	ExecuteOptions_TYPE_ONLY     ExecuteOptions_IncludedFields = 1
	ExecuteOptions_ALL           ExecuteOptions_IncludedFields = 2
)

// BindVariable represents a single bind variable in a Query.
type BindVariable struct {
	Type  Type   `protobuf:"varint,1,opt,name=type,proto3,enum=proto.Type" json:"type,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// values are set if type is TUPLE.
	Values []*Value `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
}

func (m *BindVariable) Reset()         { *m = BindVariable{} }
func (m *BindVariable) String() string { return proto.CompactTextString(m) }
func (*BindVariable) ProtoMessage()    {}

type QueryResult struct {
	Fields       []*Field `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"`
	RowsAffected uint64   `protobuf:"varint,2,opt,name=rows_affected,json=rowsAffected,proto3" json:"rows_affected,omitempty"`
	InsertId     uint64   `protobuf:"varint,3,opt,name=insert_id,json=insertId,proto3" json:"insert_id,omitempty"`
	Rows         []*Row   `protobuf:"bytes,4,rep,name=rows,proto3" json:"rows,omitempty"`
}

func (m *QueryResult) Reset()         { *m = QueryResult{} }
func (m *QueryResult) String() string { return proto.CompactTextString(m) }
func (*QueryResult) ProtoMessage()    {}
func (*QueryResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c6ac9b241082464, []int{9}
}

func (m *QueryResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryResult.Unmarshal(m, b)
}
func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
}
func (m *QueryResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryResult.Merge(m, src)
}
func (m *QueryResult) XXX_Size() int {
	return xxx_messageInfo_QueryResult.Size(m)
}
func (m *QueryResult) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryResult.DiscardUnknown(m)
}

var xxx_messageInfo_QueryResult proto.InternalMessageInfo

type ResultWithError struct {
	// error contains an query level error, only set if result is unset.
	Error error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// result contains the query result, only set if error is unset.
	Result *QueryResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
}

func (m *ResultWithError) Reset()         { *m = ResultWithError{} }
func (m *ResultWithError) String() string { return proto.CompactTextString(m) }
func (*ResultWithError) ProtoMessage()    {}

type EventToken struct {
	// timestamp is the MySQL timestamp of the statements. Seconds since Epoch.
	Timestamp int64
	// The shard name that applied the statements. Note this is not set when
	// streaming from a vttablet. It is only used on the client -> vtgate link.
	Shard string
	// The position on the replication stream after this statement was applied.
	// It is not the transaction ID / GTID, but the position / GTIDSet.
	Position string
}

func (m *EventToken) Reset()         { *m = EventToken{} }
func (m *EventToken) String() string { return proto.CompactTextString(m) }
func (*EventToken) ProtoMessage()    {}

type Value struct {
	Type  Type   `protobuf:"varint,1,opt,name=type,proto3,enum=proto.Type" json:"type,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *Value) Reset()         { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage()    {}

type ExecuteOptions_Workload int32
type ExecuteOptions_TransactionIsolation int32
type ExecuteOptions_PlannerVersion int32

type ExecuteOptions struct {
	// Controls what fields are returned in Field message responses from mysql, i.e.
	// field name, table name, etc. This is an optimization for high-QPS queries where
	// the client knows what it's getting
	IncludedFields ExecuteOptions_IncludedFields
	// client_rows_found specifies if rows_affected should return
	// rows found instead of rows affected. Behavior is defined
	// by MySQL's CLIENT_FOUND_ROWS flag.
	ClientFoundRows bool
	// workload specifies the type of workload:
	// OLTP: DMLs allowed, results have row count limit, and
	// query timeouts are shorter.
	// OLAP: DMLS not allowed, no limit on row count, timeouts
	// can be as high as desired.
	// DBA: no limit on rowcount or timeout, all queries allowed
	// but intended for long DMLs and DDLs.
	Workload ExecuteOptions_Workload
	// sql_select_limit sets an implicit limit on all select statements. Since
	// vitess also sets a rowcount limit on queries, the smallest value wins.
	SqlSelectLimit       int64
	TransactionIsolation ExecuteOptions_TransactionIsolation
	// skip_query_plan_cache specifies if the query plan should be cached by vitess.
	// By default all query plans are cached.
	SkipQueryPlanCache bool
	// PlannerVersion specifies which planner to use.
	// If DEFAULT is chosen, whatever vtgate was started with will be used
	PlannerVersion ExecuteOptions_PlannerVersion
}

type BoundQuery struct {
	// sql is the SQL query to execute
	Sql string
	// bind_variables is a map of all bind variables to expand in the query.
	// nil values are not allowed. Use NULL_TYPE to express a NULL value.
	BindVariables map[string]*BindVariable
}

func (m *BoundQuery) Reset()         { *m = BoundQuery{} }
func (m *BoundQuery) String() string { return proto.CompactTextString(m) }
func (*BoundQuery) ProtoMessage()    {}

var fileDescriptor_5c6ac9b241082464 = []byte{
	// 3235 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4b, 0x70, 0x1b, 0x5b,
	0x5a, 0x76, 0xb7, 0x1e, 0x96, 0x7e, 0x59, 0xf2, 0xf1, 0xb1, 0x9d, 0xab, 0xeb, 0xdc, 0x87, 0xa7,
	0x67, 0x32, 0x63, 0x0c, 0x38, 0x89, 0xe3, 0x09, 0xe1, 0xce, 0x00, 0x69, 0xcb, 0xed, 0x5c, 0x25,
	0x52, 0x4b, 0x39, 0x6a, 0x39, 0x93, 0x14, 0x55, 0x5d, 0x6d, 0xe9, 0x44, 0xee, 0x72, 0x4b, 0xad,
	0x74, 0xb7, 0x9d, 0x68, 0x17, 0x18, 0x86, 0xe1, 0xcd, 0xf0, 0x66, 0x98, 0x62, 0x8a, 0x2a, 0x16,
	0x14, 0x1b, 0xd6, 0xac, 0x59, 0xdc, 0x05, 0x0b, 0xaa, 0x58, 0x02, 0x55, 0x3c, 0x16, 0x14, 0xac,
	0xa6, 0x28, 0x16, 0x2c, 0x58, 0x50, 0xd4, 0x79, 0x74, 0x4b, 0xb2, 0x75, 0x13, 0x4f, 0x86, 0x29,
	0x2a, 0xb9, 0x59, 0xe9, 0xfc, 0x8f, 0xf3, 0xf8, 0xbf, 0xf3, 0x9f, 0xff, 0x3f, 0xfd, 0xeb, 0x40,
	0xe1, 0xc9, 0x09, 0x0d, 0x46, 0x5b, 0xc3, 0xc0, 0x8f, 0x7c, 0x9c, 0xe1, 0xc4, 0x5a, 0x29, 0xf2,
	0x87, 0x7e, 0xd7, 0x89, 0x1c, 0xc1, 0x5e, 0x2b, 0x9c, 0x46, 0xc1, 0xb0, 0x23, 0x08, 0xed, 0x1b,
	0x0a, 0x64, 0x2d, 0x27, 0xe8, 0xd1, 0x08, 0xaf, 0x41, 0xee, 0x98, 0x8e, 0xc2, 0xa1, 0xd3, 0xa1,
	0x65, 0x65, 0x5d, 0xd9, 0xc8, 0x93, 0x84, 0xc6, 0x2b, 0x90, 0x09, 0x8f, 0x9c, 0xa0, 0x5b, 0x56,
	0xb9, 0x40, 0x10, 0xf8, 0xcb, 0x50, 0x88, 0x9c, 0x43, 0x8f, 0x46, 0x76, 0x34, 0x1a, 0xd2, 0x72,
	0x6a, 0x5d, 0xd9, 0x28, 0x6d, 0xaf, 0x6c, 0x25, 0xf3, 0x59, 0x5c, 0x68, 0x8d, 0x86, 0x94, 0x40,
	0x94, 0xb4, 0x31, 0x86, 0x74, 0x87, 0x7a, 0x5e, 0x39, 0xcd, 0xc7, 0xe2, 0x6d, 0x6d, 0x0f, 0x4a,
	0x07, 0xd6, 0x1d, 0x27, 0xa2, 0x15, 0xc7, 0xf3, 0x68, 0x50, 0xdd, 0x63, 0xcb, 0x39, 0x09, 0x69,
	0x30, 0x70, 0xfa, 0xc9, 0x72, 0x62, 0x1a, 0x5f, 0x82, 0x6c, 0x2f, 0xf0, 0x4f, 0x86, 0x61, 0x59,
	0x5d, 0x4f, 0x6d, 0xe4, 0x89, 0xa4, 0xb4, 0x9f, 0x05, 0x30, 0x4e, 0xe9, 0x20, 0xb2, 0xfc, 0x63,
	0x3a, 0xc0, 0xef, 0x41, 0x3e, 0x72, 0xfb, 0x34, 0x8c, 0x9c, 0xfe, 0x90, 0x0f, 0x91, 0x22, 0x63,
	0xc6, 0xa7, 0x98, 0xb4, 0x06, 0xb9, 0xa1, 0x1f, 0xba, 0x91, 0xeb, 0x0f, 0xb8, 0x3d, 0x79, 0x92,
	0xd0, 0xda, 0x4f, 0x43, 0xe6, 0xc0, 0xf1, 0x4e, 0x28, 0xfe, 0x10, 0xd2, 0xdc, 0x60, 0x85, 0x1b,
	0x5c, 0xd8, 0x12, 0xa0, 0x73, 0x3b, 0xb9, 0x80, 0x8d, 0x7d, 0xca, 0x34, 0xf9, 0xd8, 0x0b, 0x44,
	0x10, 0xda, 0x31, 0x2c, 0xec, 0xba, 0x83, 0xee, 0x81, 0x13, 0xb8, 0x0c, 0x8c, 0x57, 0x1c, 0x06,
	0x7f, 0x01, 0xb2, 0xbc, 0x11, 0x96, 0x53, 0xeb, 0xa9, 0x8d, 0xc2, 0xf6, 0x82, 0xec, 0xc8, 0xd7,
	0x46, 0xa4, 0x4c, 0xfb, 0x2b, 0x05, 0x60, 0xd7, 0x3f, 0x19, 0x74, 0xef, 0x33, 0x21, 0x46, 0x90,
	0x0a, 0x9f, 0x78, 0x12, 0x48, 0xd6, 0xc4, 0xf7, 0xa0, 0x74, 0xe8, 0x0e, 0xba, 0xf6, 0xa9, 0x5c,
	0x8e, 0xc0, 0xb2, 0xb0, 0xfd, 0x05, 0x39, 0xdc, 0xb8, 0xf3, 0xd6, 0xe4, 0xaa, 0x43, 0x63, 0x10,
	0x05, 0x23, 0x52, 0x3c, 0x9c, 0xe4, 0xad, 0xb5, 0x01, 0x9f, 0x57, 0x62, 0x93, 0x1e, 0xd3, 0x51,
	0x3c, 0xe9, 0x31, 0x1d, 0xe1, 0x1f, 0x99, 0xb4, 0xa8, 0xb0, 0xbd, 0x1c, 0xcf, 0x35, 0xd1, 0x57,
	0x9a, 0xf9, 0x91, 0x7a, 0x4b, 0xd1, 0xfe, 0x31, 0x0b, 0x25, 0xe3, 0x19, 0xed, 0x9c, 0x44, 0xb4,
	0x31, 0x64, 0x7b, 0x10, 0xe2, 0x3a, 0x2c, 0xba, 0x83, 0x8e, 0x77, 0xd2, 0xa5, 0x5d, 0xfb, 0xb1,
	0x4b, 0xbd, 0x6e, 0xc8, 0xfd, 0xa8, 0x94, 0xac, 0x7b, 0x5a, 0x7f, 0xab, 0x2a, 0x95, 0xf7, 0xb9,
	0x2e, 0x29, 0xb9, 0x53, 0x34, 0xde, 0x84, 0xa5, 0x8e, 0xe7, 0xd2, 0x41, 0x64, 0x3f, 0x66, 0xf6,
	0xda, 0x81, 0xff, 0x34, 0x2c, 0x67, 0xd6, 0x95, 0x8d, 0x1c, 0x59, 0x14, 0x82, 0x7d, 0xc6, 0x27,
	0xfe, 0xd3, 0x10, 0x7f, 0x04, 0xb9, 0xa7, 0x7e, 0x70, 0xec, 0xf9, 0x4e, 0xb7, 0x9c, 0xe5, 0x73,
	0x7e, 0x30, 0x7b, 0xce, 0x07, 0x52, 0x8b, 0x24, 0xfa, 0x78, 0x03, 0x50, 0xf8, 0xc4, 0xb3, 0x43,
	0xea, 0xd1, 0x4e, 0x64, 0x7b, 0x6e, 0xdf, 0x8d, 0xca, 0x39, 0xee, 0x92, 0xa5, 0xf0, 0x89, 0xd7,
	0xe2, 0xec, 0x1a, 0xe3, 0x62, 0x1b, 0x56, 0xa3, 0xc0, 0x19, 0x84, 0x4e, 0x87, 0x0d, 0x66, 0xbb,
	0xa1, 0xef, 0x39, 0xdc, 0x1d, 0xf3, 0x7c, 0xca, 0xcd, 0xd9, 0x53, 0x5a, 0xe3, 0x2e, 0xd5, 0xb8,
	0x07, 0x59, 0x89, 0x66, 0x70, 0xf1, 0x75, 0x58, 0x0d, 0x8f, 0xdd, 0xa1, 0xcd, 0xc7, 0xb1, 0x87,
	0x9e, 0x33, 0xb0, 0x3b, 0x4e, 0xe7, 0x88, 0x96, 0x81, 0x9b, 0x8d, 0x99, 0x90, 0xef, 0x7b, 0xd3,
	0x73, 0x06, 0x15, 0x26, 0x61, 0xa0, 0x33, 0xbd, 0x01, 0x0d, 0xec, 0x53, 0x1a, 0x84, 0x6c, 0x35,
	0x85, 0x17, 0x81, 0xde, 0x14, 0xca, 0x07, 0x42, 0x97, 0x94, 0x86, 0x53, 0xb4, 0xf6, 0x15, 0x28,
	0x4d, 0x6f, 0x0b, 0x5e, 0x82, 0xa2, 0xf5, 0xb0, 0x69, 0xd8, 0xba, 0xb9, 0x67, 0x9b, 0x7a, 0xdd,
	0x40, 0x73, 0xb8, 0x08, 0x79, 0xce, 0x6a, 0x98, 0xb5, 0x87, 0x48, 0xc1, 0xf3, 0x90, 0xd2, 0x6b,
	0x35, 0xa4, 0x6a, 0xb7, 0x20, 0x17, 0xe3, 0x8b, 0x17, 0xa1, 0xd0, 0x36, 0x5b, 0x4d, 0xa3, 0x52,
	0xdd, 0xaf, 0x1a, 0x7b, 0x68, 0x0e, 0xe7, 0x20, 0xdd, 0xa8, 0x59, 0x4d, 0xa4, 0x88, 0x96, 0xde,
	0x44, 0x2a, 0xeb, 0xb9, 0xb7, 0xab, 0xa3, 0x94, 0xf6, 0x67, 0x0a, 0xac, 0xcc, 0xc2, 0x09, 0x17,
	0x60, 0x7e, 0xcf, 0xd8, 0xd7, 0xdb, 0x35, 0x0b, 0xcd, 0xe1, 0x65, 0x58, 0x24, 0x46, 0xd3, 0xd0,
	0x2d, 0x7d, 0xb7, 0x66, 0xd8, 0xc4, 0xd0, 0xf7, 0x90, 0x82, 0x31, 0x94, 0x58, 0xcb, 0xae, 0x34,
	0xea, 0xf5, 0xaa, 0x65, 0x19, 0x7b, 0x48, 0xc5, 0x2b, 0x80, 0x38, 0xaf, 0x6d, 0x8e, 0xb9, 0x29,
	0x8c, 0x60, 0xa1, 0x65, 0x90, 0xaa, 0x5e, 0xab, 0x3e, 0x62, 0x03, 0xa0, 0x34, 0xfe, 0x1c, 0xbc,
	0x5f, 0x69, 0x98, 0xad, 0x6a, 0xcb, 0x32, 0x4c, 0xcb, 0x6e, 0x99, 0x7a, 0xb3, 0xf5, 0x71, 0xc3,
	0xe2, 0x23, 0x0b, 0xe3, 0x32, 0xb8, 0x04, 0xa0, 0xb7, 0xad, 0x86, 0x18, 0x07, 0x65, 0xb5, 0x36,
	0x94, 0xa6, 0x21, 0x64, 0xab, 0x92, 0x4b, 0xb4, 0x9b, 0x35, 0xdd, 0x34, 0x0d, 0x82, 0xe6, 0x70,
	0x16, 0xd4, 0x83, 0x1b, 0x48, 0xe1, 0xbf, 0x3b, 0x48, 0xc5, 0x0b, 0x90, 0x3b, 0xd8, 0xb9, 0x13,
	0x50, 0xda, 0x1d, 0x89, 0x95, 0x1c, 0xec, 0xd4, 0xe8, 0xe3, 0x68, 0x9b, 0xb8, 0xbd, 0xa3, 0x08,
	0xa5, 0xef, 0xa6, 0x73, 0x0a, 0x52, 0xef, 0xa6, 0x73, 0x2a, 0x4a, 0xdd, 0x4d, 0xe7, 0x52, 0x28,
	0xad, 0xfd, 0xa5, 0x0a, 0x19, 0xbe, 0x05, 0x2c, 0x28, 0x4f, 0x84, 0x5a, 0xde, 0x4e, 0x02, 0x94,
	0xfa, 0x82, 0x00, 0xc5, 0xe3, 0xba, 0x0c, 0x95, 0x82, 0xc0, 0x97, 0x21, 0xef, 0x07, 0x3d, 0x5b,
	0x48, 0x44, 0x90, 0xcf, 0xf9, 0x41, 0x8f, 0x67, 0x03, 0x16, 0x60, 0x59, 0x6e, 0x38, 0x74, 0x42,
	0xca, 0xcf, 0x59, 0x9e, 0x24, 0x34, 0x7e, 0x17, 0x98, 0x9e, 0xcd, 0xd7, 0x91, 0xe5, 0xb2, 0x79,
	0x3f, 0xe8, 0x99, 0x6c, 0x29, 0x9f, 0x87, 0x62, 0xc7, 0xf7, 0x4e, 0xfa, 0x03, 0xdb, 0xa3, 0x83,
	0x5e, 0x74, 0x54, 0x9e, 0x5f, 0x57, 0x36, 0x8a, 0x64, 0x41, 0x30, 0x6b, 0x9c, 0x87, 0xcb, 0x30,
	0xdf, 0x39, 0x72, 0x82, 0x90, 0x8a, 0xb3, 0x55, 0x24, 0x31, 0xc9, 0x67, 0xa5, 0x1d, 0xb7, 0xef,
	0x78, 0x21, 0x3f, 0x47, 0x45, 0x92, 0xd0, 0xcc, 0x88, 0xc7, 0x9e, 0xd3, 0x0b, 0xb9, 0xff, 0x17,
	0x89, 0x20, 0xf0, 0x87, 0x50, 0x90, 0x13, 0x72, 0x08, 0x0a, 0x7c, 0x39, 0x20, 0x58, 0x0c, 0x01,
	0xed, 0x27, 0x20, 0x45, 0xfc, 0xa7, 0x6c, 0x4e, 0xb1, 0xa2, 0xb0, 0xac, 0xac, 0xa7, 0x36, 0x30,
	0x89, 0x49, 0x96, 0xa4, 0x64, 0x9c, 0x16, 0xe1, 0x3b, 0x8e, 0xcc, 0xdf, 0x51, 0xa0, 0xc0, 0xcf,
	0x17, 0xa1, 0xe1, 0x89, 0x17, 0xb1, 0x78, 0x2e, 0x03, 0x99, 0x32, 0x15, 0xcf, 0xf9, 0xbe, 0x10,
	0x29, 0x63, 0x00, 0xb0, 0xd8, 0x64, 0x3b, 0x8f, 0x1f, 0xd3, 0x4e, 0x44, 0x45, 0xda, 0x4a, 0x93,
	0x05, 0xc6, 0xd4, 0x25, 0x8f, 0x21, 0xef, 0x0e, 0x42, 0x1a, 0x44, 0xb6, 0xdb, 0xe5, 0x7b, 0x92,
	0x26, 0x39, 0xc1, 0xa8, 0x76, 0xf1, 0x07, 0x90, 0xe6, 0xd1, 0x2d, 0xcd, 0x67, 0x01, 0x39, 0x0b,
	0xf1, 0x9f, 0x12, 0xce, 0xbf, 0x9b, 0xce, 0x65, 0x50, 0x56, 0xfb, 0x2a, 0x2c, 0xf0, 0xc5, 0x3d,
	0x70, 0x82, 0x81, 0x3b, 0xe8, 0xf1, 0x64, 0xed, 0x77, 0x85, 0x5f, 0x14, 0x09, 0x6f, 0x33, 0x9b,
	0xfb, 0x34, 0x0c, 0x9d, 0x1e, 0x95, 0xc9, 0x33, 0x26, 0xb5, 0x3f, 0x49, 0x41, 0xa1, 0x15, 0x05,
	0xd4, 0xe9, 0xf3, 0x3c, 0x8c, 0xbf, 0x0a, 0x10, 0x46, 0x4e, 0x44, 0xfb, 0x74, 0x10, 0xc5, 0xf6,
	0xbd, 0x27, 0x67, 0x9e, 0xd0, 0xdb, 0x6a, 0xc5, 0x4a, 0x64, 0x42, 0x1f, 0x6f, 0x43, 0x81, 0x32,
	0xb1, 0x1d, 0xb1, 0x7c, 0x2e, 0x73, 0xc6, 0x52, 0x1c, 0x72, 0x92, 0x44, 0x4f, 0x80, 0x26, 0xed,
	0xb5, 0xef, 0xaa, 0x90, 0x4f, 0x46, 0xc3, 0x3a, 0xe4, 0x3a, 0x4e, 0x44, 0x7b, 0x7e, 0x30, 0x92,
	0x69, 0xf6, 0xca, 0x8b, 0x66, 0xdf, 0xaa, 0x48, 0x65, 0x92, 0x74, 0xc3, 0xef, 0x83, 0xb8, 0xbb,
	0x08, 0xb7, 0x14, 0xf6, 0xe6, 0x39, 0x87, 0x3b, 0xe6, 0x47, 0x80, 0x87, 0x81, 0xdb, 0x77, 0x82,
	0x91, 0x7d, 0x4c, 0x47, 0x71, 0x4a, 0x4a, 0xcd, 0xd8, 0x49, 0x24, 0xf5, 0xee, 0xd1, 0x91, 0x8c,
	0x7a, 0xb7, 0xa6, 0xfb, 0x4a, 0x6f, 0x39, 0xbf, 0x3f, 0x13, 0x3d, 0x79, 0x92, 0x0f, 0xe3, 0x74,
	0x9e, 0xe1, 0x8e, 0xc5, 0x9a, 0xda, 0x97, 0x20, 0x17, 0x2f, 0x1e, 0xe7, 0x21, 0x63, 0x04, 0x81,
	0x1f, 0xa0, 0x39, 0x1e, 0xfc, 0xea, 0x35, 0x11, 0x3f, 0xf7, 0xf6, 0x58, 0xfc, 0xfc, 0x17, 0x35,
	0xc9, 0xa9, 0x84, 0x3e, 0x39, 0xa1, 0x61, 0x84, 0x7f, 0x06, 0x96, 0x29, 0x77, 0x21, 0xf7, 0x94,
	0xda, 0x1d, 0x7e, 0x01, 0x63, 0x0e, 0xa4, 0x70, 0xbc, 0x17, 0xb7, 0xc4, 0x7d, 0x31, 0xbe, 0x98,
	0x91, 0xa5, 0x44, 0x57, 0xb2, 0xba, 0xd8, 0x80, 0x65, 0xb7, 0xdf, 0xa7, 0x5d, 0xd7, 0x89, 0x26,
	0x07, 0x10, 0x1b, 0xb6, 0x1a, 0xdf, 0x4f, 0xa6, 0xee, 0x77, 0x64, 0x29, 0xe9, 0x91, 0x0c, 0x73,
	0x05, 0xb2, 0x11, 0xbf, 0x8b, 0x72, 0xdf, 0x2d, 0x6c, 0x17, 0xe3, 0x88, 0xc3, 0x99, 0x44, 0x0a,
	0xf1, 0x97, 0x40, 0xdc, 0x6c, 0x79, 0x6c, 0x19, 0x3b, 0xc4, 0xf8, 0xc2, 0x42, 0x84, 0x1c, 0x5f,
	0x81, 0xd2, 0x54, 0x2a, 0xed, 0x72, 0xc0, 0x52, 0xa4, 0x38, 0x99, 0x17, 0xbb, 0xf8, 0x2a, 0xcc,
	0xfb, 0x22, 0x71, 0xf1, 0xa8, 0x33, 0x5e, 0xf1, 0x74, 0x56, 0x23, 0xb1, 0x16, 0x8b, 0x0d, 0x01,
	0x0d, 0x69, 0x70, 0x4a, 0xbb, 0x6c, 0xd0, 0x79, 0x3e, 0x28, 0xc4, 0xac, 0x6a, 0x57, 0xfb, 0x29,
	0x58, 0x4c, 0x20, 0x0e, 0x87, 0xfe, 0x20, 0xa4, 0x78, 0x13, 0xb2, 0x01, 0x3f, 0xef, 0x12, 0x56,
	0x2c, 0xe7, 0x98, 0x88, 0x04, 0x44, 0x6a, 0x68, 0x5d, 0x58, 0x14, 0x9c, 0x07, 0x6e, 0x74, 0xc4,
	0x77, 0x12, 0x5f, 0x81, 0x0c, 0x65, 0x8d, 0x33, 0x9b, 0x42, 0x9a, 0x15, 0x2e, 0x27, 0x42, 0x3a,
	0x31, 0x8b, 0xfa, 0xd2, 0x59, 0xfe, 0x43, 0x85, 0x65, 0xb9, 0xca, 0x5d, 0x27, 0xea, 0x1c, 0xbd,
	0xa6, 0xde, 0xf0, 0xa3, 0x30, 0xcf, 0xf8, 0x6e, 0x72, 0x72, 0x66, 0xf8, 0x43, 0xac, 0xc1, 0x3c,
	0xc2, 0x09, 0xed, 0x89, 0xed, 0x97, 0x77, 0xbd, 0xa2, 0x13, 0x4e, 0xdc, 0x0c, 0x66, 0x38, 0x4e,
	0xf6, 0x25, 0x8e, 0x33, 0x7f, 0x11, 0xc7, 0xd1, 0xf6, 0x60, 0x65, 0x1a, 0x71, 0xe9, 0x1c, 0x3f,
	0x06, 0xf3, 0x62, 0x53, 0xe2, 0x18, 0x39, 0x6b, 0xdf, 0x62, 0x15, 0xed, 0x13, 0x15, 0x56, 0x64,
	0xf8, 0xfa, 0x6c, 0x9c, 0xe3, 0x09, 0x9c, 0x33, 0x17, 0x3a, 0xa0, 0x17, 0xdb, 0x3f, 0xad, 0x02,
	0xab, 0x67, 0x70, 0x7c, 0x85, 0xc3, 0xfa, 0x3d, 0x05, 0x16, 0x76, 0x69, 0xcf, 0x1d, 0xbc, 0xa6,
	0xbb, 0x30, 0x01, 0x6e, 0xfa, 0x42, 0x4e, 0x3c, 0x84, 0xa2, 0xb4, 0x57, 0xa2, 0x75, 0x1e, 0x6d,
	0x65, 0xd6, 0x69, 0xb9, 0x05, 0x0b, 0xb2, 0x5a, 0xe0, 0x78, 0xae, 0x13, 0x26, 0xf6, 0x9c, 0x29,
	0x17, 0xe8, 0x4c, 0x48, 0x64, 0x61, 0x81, 0x13, 0xda, 0xbf, 0x2a, 0x50, 0xac, 0xf8, 0xfd, 0xbe,
	0x1b, 0xbd, 0xa6, 0x18, 0x9f, 0x47, 0x28, 0x3d, 0xcb, 0x1f, 0xaf, 0x43, 0x29, 0x36, 0x53, 0x42,
	0x7b, 0x26, 0xd3, 0x28, 0xe7, 0x32, 0xcd, 0xbf, 0x29, 0xb0, 0x48, 0x7c, 0xcf, 0x3b, 0x74, 0x3a,
	0xc7, 0x6f, 0x36, 0x38, 0x37, 0x00, 0x8d, 0x0d, 0xbd, 0x28, 0x3c, 0xff, 0xad, 0x40, 0xa9, 0x19,
	0xd0, 0xa1, 0x13, 0xd0, 0x37, 0x1a, 0x1d, 0x76, 0x4d, 0xef, 0x46, 0xf2, 0x82, 0x93, 0x27, 0xbc,
	0xad, 0x2d, 0xc1, 0x62, 0x62, 0xbb, 0x00, 0x4c, 0xfb, 0x7b, 0x05, 0x56, 0x85, 0x8b, 0x49, 0x49,
	0xf7, 0x35, 0x85, 0x25, 0xb6, 0x37, 0x3d, 0x61, 0x6f, 0x19, 0x2e, 0x9d, 0xb5, 0x4d, 0x9a, 0xfd,
	0x75, 0x15, 0xde, 0x89, 0x9d, 0xe7, 0x35, 0x37, 0xfc, 0x07, 0xf0, 0x87, 0x35, 0x28, 0x9f, 0x07,
	0x41, 0x22, 0xf4, 0x2d, 0x15, 0xca, 0x95, 0x80, 0x3a, 0x11, 0x9d, 0xb8, 0x07, 0xbd, 0x39, 0xbe,
	0x81, 0xaf, 0xc3, 0xc2, 0xd0, 0x09, 0x22, 0xb7, 0xe3, 0x0e, 0x1d, 0xf6, 0x29, 0x9a, 0xe1, 0xd7,
	0xac, 0x33, 0x03, 0x4c, 0xa9, 0x68, 0x97, 0xe1, 0xdd, 0x19, 0x88, 0x48, 0xbc, 0xfe, 0x47, 0x01,
	0xdc, 0x8a, 0x9c, 0x20, 0xfa, 0x0c, 0xe4, 0xa5, 0x99, 0xce, 0xb4, 0x0a, 0xcb, 0x53, 0xf6, 0x4f,
	0xe2, 0x42, 0xa3, 0xcf, 0x44, 0x4a, 0xfa, 0x54, 0x5c, 0x26, 0xed, 0x97, 0xb8, 0xfc, 0x93, 0x02,
	0x6b, 0x15, 0x5f, 0x14, 0x3d, 0xdf, 0xc8, 0x13, 0xa6, 0xbd, 0x0f, 0x97, 0x67, 0x1a, 0x28, 0x01,
	0xf8, 0x07, 0x05, 0x2e, 0x11, 0xea, 0x74, 0xdf, 0x4c, 0xe3, 0xef, 0xc3, 0x3b, 0xe7, 0x8c, 0x93,
	0x77, 0x94, 0x9b, 0x90, 0xeb, 0xd3, 0xc8, 0x61, 0x37, 0x5c, 0x69, 0xd2, 0x5a, 0x3c, 0xee, 0x58,
	0xbb, 0x2e, 0x35, 0x48, 0xa2, 0xab, 0xfd, 0xb3, 0x0a, 0xcb, 0xfc, 0x9e, 0xfd, 0xf6, 0x23, 0xef,
	0x42, 0x55, 0x98, 0xec, 0xd9, 0xcb, 0x1f, 0x53, 0x18, 0x06, 0xd4, 0x8e, 0xab, 0x03, 0xf3, 0xfc,
	0xaf, 0x42, 0x18, 0x06, 0xf4, 0xbe, 0xe0, 0x68, 0x7f, 0xad, 0xc0, 0xca, 0x34, 0xc4, 0xc9, 0x17,
	0xcd, 0xff, 0x75, 0xb5, 0x65, 0x46, 0x48, 0x49, 0x5d, 0xe4, 0x23, 0x29, 0x7d, 0xe1, 0x8f, 0xa4,
	0xbf, 0x51, 0xa1, 0x3c, 0x69, 0xcc, 0xdb, 0x9a, 0xce, 0x74, 0x4d, 0xe7, 0xfb, 0xad, 0xf2, 0x69,
	0x7f, 0xab, 0xc0, 0xbb, 0x33, 0x00, 0xfd, 0xfe, 0x5c, 0x64, 0xa2, 0xb2, 0xa3, 0xbe, 0xb4, 0xb2,
	0xf3, 0xc3, 0x77, 0x92, 0xbf, 0x53, 0x60, 0xa5, 0x2e, 0x6a, 0xf5, 0xa2, 0xf2, 0xf1, 0xfa, 0xc6,
	0x60, 0x5e, 0x8e, 0x4f, 0x8f, 0xff, 0xad, 0xd2, 0x2a, 0xb0, 0x7a, 0xc6, 0xb4, 0x57, 0xa8, 0xe6,
	0xfc, 0x97, 0x02, 0x4b, 0x72, 0x14, 0xfd, 0xb5, 0xbd, 0xbe, 0xcc, 0x40, 0x07, 0x7f, 0x00, 0x29,
	0xb7, 0x1b, 0xdf, 0x7b, 0xa7, 0x9f, 0x0c, 0x30, 0x81, 0x76, 0x1b, 0xf0, 0xa4, 0xdd, 0xaf, 0x00,
	0xdd, 0xbf, 0xab, 0xb0, 0x4a, 0x44, 0xf4, 0x7d, 0xfb, 0xff, 0xc2, 0x0f, 0xfa, 0xff, 0xc2, 0x8b,
	0x13, 0xd7, 0x27, 0xfc, 0x32, 0x35, 0x0d, 0xf5, 0x0f, 0x2f, 0x75, 0x9d, 0x49, 0xb4, 0xa9, 0x73,
	0x89, 0xf6, 0xd5, 0xe3, 0xd1, 0x27, 0x2a, 0xac, 0x49, 0x43, 0xde, 0xde, 0x75, 0x2e, 0xee, 0x11,
	0xd9, 0x73, 0x1e, 0xf1, 0x9f, 0x0a, 0x5c, 0x9e, 0x09, 0xe4, 0xff, 0xfb, 0x8d, 0xe6, 0x8c, 0xf7,
	0xa4, 0x5f, 0xea, 0x3d, 0x99, 0x0b, 0x7b, 0xcf, 0x37, 0x55, 0x28, 0x11, 0xea, 0x51, 0x27, 0x7c,
	0xc3, 0xab, 0x7b, 0x67, 0x30, 0xcc, 0x9c, 0xab, 0x73, 0x2e, 0xc1, 0x62, 0x02, 0x84, 0xfc, 0xe0,
	0xe2, 0x1f, 0xe8, 0x2c, 0x0f, 0x7e, 0x4c, 0x1d, 0x2f, 0x8a, 0x6f, 0x82, 0xda, 0x9f, 0xaa, 0x50,
	0x24, 0x8c, 0xe3, 0xf6, 0x69, 0x2b, 0x72, 0xa2, 0x10, 0x7f, 0x0e, 0x16, 0x8e, 0xb8, 0x8a, 0x3d,
	0xf6, 0x90, 0x3c, 0x29, 0x08, 0x9e, 0xf8, 0xf7, 0x71, 0x1b, 0x56, 0x43, 0xda, 0xf1, 0x07, 0xdd,
	0xd0, 0x3e, 0xa4, 0x47, 0xee, 0xa0, 0x6b, 0xf7, 0x9d, 0x30, 0xa2, 0x01, 0x87, 0xa5, 0x48, 0x96,
	0xa5, 0x70, 0x97, 0xcb, 0xea, 0x5c, 0x84, 0xaf, 0xc1, 0xca, 0xa1, 0x3b, 0xf0, 0xfc, 0x9e, 0x3d,
	0xf4, 0x9c, 0x11, 0x0d, 0x42, 0xbb, 0xe3, 0x9f, 0x0c, 0x04, 0x1e, 0x19, 0x82, 0x85, 0xac, 0x29,
	0x44, 0x15, 0x26, 0xc1, 0x8f, 0x60, 0x73, 0xe6, 0x2c, 0xf6, 0x63, 0xd7, 0x8b, 0x68, 0x40, 0xbb,
	0x76, 0x40, 0x87, 0x9e, 0xdb, 0x11, 0xcf, 0xa1, 0x04, 0x50, 0x5f, 0x9c, 0x31, 0xf5, 0xbe, 0x54,
	0x27, 0x63, 0x6d, 0x7c, 0x19, 0xf2, 0x9d, 0xe1, 0x89, 0x7d, 0xc2, 0x1f, 0x2d, 0x30, 0xfc, 0x14,
	0x92, 0xeb, 0x0c, 0x4f, 0xda, 0x8c, 0xc6, 0x08, 0x52, 0x4f, 0x86, 0x22, 0x38, 0x2b, 0x84, 0x35,
	0xb5, 0xef, 0x29, 0x50, 0xd2, 0x7b, 0xbd, 0x80, 0xf6, 0x9c, 0x48, 0xc2, 0x74, 0x0d, 0x56, 0x04,
	0x24, 0x23, 0x5b, 0xba, 0xab, 0xb0, 0x47, 0x11, 0xf6, 0x48, 0x99, 0xf0, 0x55, 0x61, 0xcf, 0x0e,
	0x5c, 0x3a, 0x19, 0xcc, 0xec, 0xa3, 0xf2, 0x3e, 0x2b, 0x89, 0x74, 0xb2, 0xd7, 0x4f, 0xc2, 0xbb,
	0xb3, 0x51, 0xe8, 0xbb, 0xe2, 0x49, 0x62, 0x91, 0x5c, 0x9a, 0x61, 0x74, 0xdd, 0x1d, 0xbc, 0xa0,
	0xab, 0xf3, 0x8c, 0xe3, 0xf5, 0x29, 0x5d, 0x9d, 0x67, 0xda, 0x9f, 0x27, 0xff, 0x29, 0xc6, 0xee,
	0x92, 0x04, 0x8e, 0xd8, 0x91, 0x95, 0x17, 0x39, 0x72, 0x19, 0xe6, 0x99, 0x33, 0xba, 0x83, 0x1e,
	0x37, 0x2e, 0x47, 0x62, 0x12, 0xb7, 0xe0, 0x8b, 0xd2, 0x76, 0xfa, 0x2c, 0xa2, 0xc1, 0xc0, 0xf1,
	0xbc, 0x91, 0x2d, 0xca, 0x8f, 0x83, 0x88, 0x76, 0xed, 0xf1, 0x13, 0x4d, 0x11, 0x3e, 0x3e, 0x2f,
	0xb4, 0x8d, 0x44, 0x99, 0x24, 0xba, 0x56, 0xf2, 0x78, 0xf3, 0x2b, 0x50, 0x0a, 0xa4, 0x13, 0xdb,
	0x21, 0xdb, 0x1e, 0x19, 0x72, 0x57, 0xe2, 0x57, 0x13, 0x93, 0x1e, 0x4e, 0x8a, 0xc1, 0x94, 0xc3,
	0xbf, 0x72, 0xc0, 0xb9, 0x9b, 0xce, 0x65, 0xd1, 0xbc, 0xf6, 0x17, 0x0a, 0x2c, 0xcf, 0xf8, 0x76,
	0x4f, 0x0a, 0x03, 0xca, 0x44, 0xdd, 0xf1, 0xc7, 0x21, 0xc3, 0x1f, 0xb4, 0xc8, 0x37, 0x54, 0xef,
	0x9c, 0xff, 0xf4, 0xe7, 0x8f, 0x4f, 0x88, 0xd0, 0x62, 0x67, 0x91, 0xdb, 0xd4, 0xe1, 0x85, 0xc7,
	0x38, 0xa2, 0x16, 0x18, 0x4f, 0xd4, 0x22, 0xcf, 0x57, 0x32, 0xd3, 0x2f, 0xad, 0x64, 0x6e, 0xfe,
	0x76, 0x0a, 0xf2, 0xf5, 0x51, 0xeb, 0x89, 0xb7, 0xef, 0x39, 0x3d, 0xfe, 0x3a, 0xa4, 0xde, 0xb4,
	0x1e, 0xa2, 0x39, 0xbc, 0x04, 0x45, 0xb3, 0x61, 0xd9, 0x66, 0xbb, 0x56, 0xb3, 0xf7, 0x6b, 0xfa,
	0x1d, 0xa4, 0x60, 0x04, 0x0b, 0x4d, 0x52, 0xb5, 0xef, 0x19, 0x0f, 0x05, 0x47, 0xc5, 0xcb, 0xb0,
	0xd8, 0x36, 0xab, 0xf7, 0xdb, 0xc6, 0x98, 0x99, 0xc6, 0xab, 0xb0, 0x54, 0x6f, 0xd7, 0xac, 0x6a,
	0xb3, 0x36, 0xc1, 0xce, 0xe1, 0x22, 0xe4, 0x77, 0x6b, 0x8d, 0x5d, 0x41, 0x22, 0x36, 0x7e, 0xdb,
	0x6c, 0x55, 0xef, 0x98, 0xc6, 0x9e, 0x60, 0xad, 0x33, 0xd6, 0x23, 0x83, 0x34, 0xf6, 0xab, 0xf1,
	0x94, 0xb7, 0x31, 0x82, 0xc2, 0x6e, 0xd5, 0xd4, 0x89, 0x1c, 0xe5, 0xb9, 0x82, 0x4b, 0x90, 0x37,
	0xcc, 0x76, 0x5d, 0xd2, 0x2a, 0x2e, 0xc3, 0xb2, 0xde, 0xb6, 0x1a, 0x76, 0xd5, 0xac, 0x10, 0xa3,
	0x6e, 0x98, 0x96, 0x94, 0xa4, 0xf1, 0x32, 0x94, 0xac, 0x6a, 0xdd, 0x68, 0x59, 0x7a, 0xbd, 0x29,
	0x99, 0x6c, 0x15, 0xb9, 0x96, 0x11, 0xeb, 0x20, 0xbc, 0x06, 0xab, 0x66, 0xc3, 0x8e, 0x9f, 0xcf,
	0x1d, 0xe8, 0xb5, 0xb6, 0x21, 0x65, 0xeb, 0xf8, 0x1d, 0xc0, 0x0d, 0xd3, 0x6e, 0x37, 0xf7, 0x74,
	0xcb, 0xb0, 0xcd, 0xc6, 0x03, 0x29, 0xb8, 0x8d, 0x4b, 0x90, 0x1b, 0xaf, 0xe0, 0x39, 0x43, 0xa1,
	0xd8, 0xd4, 0x89, 0x35, 0x36, 0xf6, 0xf9, 0x73, 0x06, 0x16, 0xdc, 0x21, 0x8d, 0x76, 0x73, 0xac,
	0xb6, 0x04, 0x05, 0x09, 0x96, 0x64, 0xa5, 0x19, 0x6b, 0xb7, 0x6a, 0x56, 0x92, 0xf5, 0x3d, 0xcf,
	0xad, 0xa9, 0x48, 0xd9, 0x3c, 0x86, 0x34, 0xdf, 0x8e, 0x1c, 0xa4, 0xcd, 0x86, 0x69, 0xa0, 0x39,
	0xbc, 0x08, 0x50, 0x6d, 0x55, 0x4d, 0xcb, 0xb8, 0x43, 0xf4, 0x1a, 0x33, 0x9b, 0x33, 0x62, 0x00,
	0x99, 0xb5, 0x0b, 0x30, 0x5f, 0x6d, 0xed, 0xd7, 0x1a, 0xba, 0x25, 0xcd, 0xac, 0xb6, 0xee, 0xb7,
	0x1b, 0x16, 0x13, 0x22, 0x5c, 0x80, 0x6c, 0xb5, 0x65, 0x19, 0x5f, 0xb3, 0x98, 0x5d, 0x5c, 0x26,
	0x50, 0x45, 0xcf, 0x6f, 0x6f, 0x7e, 0x3b, 0x05, 0x69, 0xfe, 0xf6, 0xba, 0x08, 0x79, 0xbe, 0xdb,
	0xd6, 0xc3, 0x26, 0x9b, 0x32, 0x0f, 0xe9, 0xaa, 0x69, 0xdd, 0x42, 0x3f, 0xa7, 0x62, 0x80, 0x4c,
	0x9b, 0xb7, 0x7f, 0x3e, 0xcb, 0xda, 0x55, 0xd3, 0xba, 0x7e, 0x13, 0x7d, 0x5d, 0x65, 0xc3, 0xb6,
	0x05, 0xf1, 0x0b, 0xb1, 0x60, 0x7b, 0x07, 0x7d, 0x23, 0x11, 0x6c, 0xef, 0xa0, 0x5f, 0x8c, 0x05,
	0x37, 0xb6, 0xd1, 0x37, 0x13, 0xc1, 0x8d, 0x6d, 0xf4, 0x4b, 0xb1, 0xe0, 0xe6, 0x0e, 0xfa, 0xe5,
	0x44, 0x70, 0x73, 0x07, 0xfd, 0x4a, 0x96, 0xd9, 0xc2, 0x2d, 0xb9, 0xb1, 0x8d, 0x7e, 0x35, 0x97,
	0x50, 0x37, 0x77, 0xd0, 0xaf, 0xe5, 0xd8, 0xfe, 0x27, 0xbb, 0x8a, 0x7e, 0x1d, 0xb1, 0x65, 0xb2,
	0x0d, 0x42, 0xbf, 0xc1, 0x9b, 0x4c, 0x84, 0x7e, 0x13, 0x31, 0x1b, 0x19, 0x97, 0x93, 0xdf, 0xe2,
	0x92, 0x87, 0x86, 0x4e, 0xd0, 0x6f, 0x65, 0xc5, 0x83, 0xce, 0x4a, 0xb5, 0xae, 0xd7, 0x10, 0xe6,
	0x3d, 0x18, 0x2a, 0xbf, 0x73, 0x8d, 0x35, 0x99, 0x7b, 0xa2, 0xdf, 0x6d, 0xb2, 0x09, 0x0f, 0x74,
	0x52, 0xf9, 0x58, 0x27, 0xe8, 0xf7, 0xae, 0xb1, 0x09, 0x0f, 0x74, 0x22, 0xf1, 0xfa, 0xfd, 0x26,
	0x53, 0xe4, 0xa2, 0x3f, 0xb8, 0xc6, 0x16, 0x2d, 0xf9, 0x7f, 0xd8, 0xc4, 0x39, 0x48, 0xed, 0x56,
	0x2d, 0xf4, 0x6d, 0x3e, 0x1b, 0x73, 0x51, 0xf4, 0x47, 0x88, 0x31, 0x5b, 0x86, 0x85, 0xbe, 0xc3,
	0x98, 0x19, 0xab, 0xdd, 0xac, 0x19, 0xe8, 0x3d, 0xb6, 0xb8, 0x3b, 0x46, 0xa3, 0x6e, 0x58, 0xe4,
	0x21, 0xfa, 0x63, 0xae, 0x7e, 0xb7, 0xd5, 0x30, 0xd1, 0x77, 0x11, 0x2e, 0x01, 0x18, 0x5f, 0x6b,
	0x12, 0xa3, 0xd5, 0xaa, 0x36, 0x4c, 0xf4, 0xe1, 0xe6, 0x3e, 0xa0, 0xb3, 0xe1, 0x80, 0x19, 0xd0,
	0x36, 0xef, 0x99, 0x8d, 0x07, 0x26, 0x9a, 0x63, 0x44, 0x93, 0x18, 0x4d, 0x9d, 0x18, 0x48, 0xc1,
	0x00, 0x59, 0xf9, 0x4c, 0x94, 0xbf, 0xf7, 0x24, 0x8d, 0x5a, 0x6d, 0x57, 0xaf, 0xdc, 0x43, 0xa9,
	0xdd, 0x2f, 0xc3, 0xa2, 0xeb, 0x6f, 0x9d, 0xba, 0x11, 0x0d, 0x43, 0xf1, 0xba, 0xff, 0x91, 0x26,
	0x29, 0xd7, 0xbf, 0x2a, 0x5a, 0x57, 0x7b, 0xfe, 0xd5, 0xd3, 0xe8, 0x2a, 0x97, 0x5e, 0xe5, 0x11,
	0xe3, 0x30, 0xcb, 0x89, 0x1b, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xb2, 0x28, 0xeb, 0x3b,
	0x30, 0x00, 0x00,
}

var xxx_messageInfo_Field proto.InternalMessageInfo

func (m *Field) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Field) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ColumnType) > 0 {
		i -= len(m.ColumnType)
		copy(dAtA[i:], m.ColumnType)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ColumnType)))
		i--
		dAtA[i] = 0x5a
	}
	if m.Flags != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Flags))
		i--
		dAtA[i] = 0x50
	}
	if m.Decimals != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Decimals))
		i--
		dAtA[i] = 0x48
	}
	if m.Charset != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Charset))
		i--
		dAtA[i] = 0x40
	}
	if m.ColumnLength != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ColumnLength))
		i--
		dAtA[i] = 0x38
	}
	if len(m.OrgName) > 0 {
		i -= len(m.OrgName)
		copy(dAtA[i:], m.OrgName)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrgName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Database) > 0 {
		i -= len(m.Database)
		copy(dAtA[i:], m.Database)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Database)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.OrgTable) > 0 {
		i -= len(m.OrgTable)
		copy(dAtA[i:], m.OrgTable)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrgTable)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Table) > 0 {
		i -= len(m.Table)
		copy(dAtA[i:], m.Table)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Table)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Field) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Field: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgTable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrgTable = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Database = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrgName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnLength", wireType)
			}
			m.ColumnLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColumnLength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Charset", wireType)
			}
			m.Charset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Charset |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
			}
			m.Decimals = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Decimals |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			m.Flags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flags |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *Field) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovQuery(uint64(m.Type))
	}
	l = len(m.Table)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.OrgTable)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Database)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.OrgName)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ColumnLength != 0 {
		n += 1 + sovQuery(uint64(m.ColumnLength))
	}
	if m.Charset != 0 {
		n += 1 + sovQuery(uint64(m.Charset))
	}
	if m.Decimals != 0 {
		n += 1 + sovQuery(uint64(m.Decimals))
	}
	if m.Flags != 0 {
		n += 1 + sovQuery(uint64(m.Flags))
	}
	l = len(m.ColumnType)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func skipQuery(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)
